'''
中文教程地址：
字符串方法（String Methods）
https://docs.python.org/zh-cn/3/library/stdtypes.html#string-methods
文本序列类型 — str
https://docs.python.org/zh-cn/3/library/stdtypes.html#textseq

'''


##字符串大小写

##=========>>>title()首字母大小写

name = 'wu qingHua'
print(name.title())
#Wu Qinghua


##=========>>>upper()转为大写
print(name.upper())
#WU QINGHUA
print(name)
#wu qingHua;

##=========>>>str.capitalize()字符串开头大写，其他小写
print(name.capitalize())
#Wu qinghua
print(name)
#wu qingHua


##=========>>>lower()转为小写
print(name.lower())


##=========>>>str.casefold()返回原字符串消除大小写的副本
print(name.casefold())


##=========>>>删除空白字符
str01 = '  hel lo  '

##=========>>>删除两边
print(str01.strip())#hel lo

##=========>>>删除右边
print(str01.rstrip())#  hel lo

##=========>>>删除左边
print(str01.lstrip())#hel lo

##=========>>>删除中间空白字符
##=========>>>replace()函数，替换字符
str02 = '  hel lo  '
s = str02.replace(" ","")
print(s)#hello



##=========>>>str.center() 字符串居中

s = "hello"

# 在长度为10的字符串中将"hello"居中，使用空格填充
print(s.center(10))
#  hello

print(s.center(10,"-"))
#--hello---

print(s.center(5))
#hello



##=========>>>str.count() 计算子串在父串出现几次
#str.count(子串, 范围切片)

s = "hello"
print(s.count("l"))
#2
print(s.count("l",3))
#1
print(s.count("l",0,3))
#1


##=========>>>str.encode()返回编码为 bytes 的字符串

print(s.encode(encoding='utf-8', errors='strict'))
#b'hello'



##=========>>>str.endswith()判断字符是否以指定字符结尾

s = 'test_get_name'

print(s.endswith("name"))
#True




##=========>>>str.expandtabs(tabsize=8) 有的制表符会由一个或多个空格替换
s = 'wu\nqing\thua'
print(s.expandtabs(tabsize=4))



##=========>>>str.find(子串, 范围)  根据索引位置范围来查找。

s = 'python'
print(s.find('th'))
#2
print(s.find('th',0,2))
#-1 在范围内未找到


##=========>>> 子串 in str 判断是否包含子串
s = 'python'

print("th" in s)
#True


##=========>>> str.format(*args, **kwargs) 执行字符串格式化操作。
print("你叫{0},今年{1}岁了！".format("马超",18))
#你叫马超,今年18岁了！
print("{:n}".format(1234.2,5))
#1234.2

print("你叫{name},今年{age}岁了！".format(name="马超",age=18))
#你叫马超,今年18岁了！

print("你叫{0},今年{age}岁了！".format("马超",age=18))
#你叫马超,今年18岁了！


##=========>>> str.format_map(mapping)

# 用于进行格式化字符串操作。它接受一个字典参数mapping，
# 并使用字典中的键值对来替换格式字符串中的占位符。
ditc01 = {"name":"马超", "age":18}
print("你叫{name},今年{age}岁了！".format_map(ditc01))



##=========>>> str.index(子串,切片范围) 根据索引位置范围来查找,但在找不到子字符串时会引发 ValueError

s = "python"
print(s.index('th'))
#2
try:
    s.index('th',3,5)
except ValueError:
    print("不存在，ValueError错误")
    #不存在，ValueError错误
    


####====== 含is 的判断函数

##=========>>> str.islower() 均为小写则返回 True ，否则返回 False 

s = "hello"
print(s.islower())
# True  全小写

s = "HELLO"
print(s.islower())
#False

s = "Hello"
print(s.islower())
#False

s = "你好"
print(s.islower())


##=========>>> str.isnumeric() 是否全部为数字

s = "122315456"
print(s.isnumeric())
#True

s = "12231ww5456"
print(s.isnumeric())
#False



##=========>>> str.isprintable()  判断是否含有可打印字符（例如换行符、制表符等），手敲的空格键是可打印字符

s1 = "Hello, World!"  # 只包含可打印字符
s2 = "Hello\nWorld!"  # 包含不可打印字符

# 使用isprintable方法检查字符串是否只包含可打印字符
print(s1.isprintable())  # 输出: True
print(s2.isprintable())  # 输出: False



##=========>>> str.isspace()  判断是否只包含空白字符（例如空格、制表符、换行符等）
s = "   "
print(s.isspace())
#True  包括手敲的空格键

s = "   wd"
print(s.isspace())
#False

s = "  \t\n"
print(s.isspace())
#True



##=========>>> str.istitle()判断是否符合标题字符串

s1 = "Hello world"  # 不符合标题格式
s2 = "Hello World"    # 符合标题格式

# 使用istitle方法检查字符串是否符合标题格式
print(s1.istitle())   # 输出: False
print(s2.istitle())   # 输出: True



##=========>>> str.isupper()判断是否全大写

s1 = "WQH"
s2 = "Wqh"
s3 = "wqh"

print(s1.isupper())#True
print(s2.isupper())#False
print(s3.isupper())#False


##=========>>> str.join(iterable) 拼接可迭代对象
# 替代符号.join(可迭代对象)

list02 = ['a','b','c']
new_str = '-'.join(list02)
print(new_str)
#a-b-c

# 使用join方法连接列表中的元素
my_list = ['Hello', 'World', '!']
result = ' '.join(my_list)
print(result)  # 输出: Hello World !

# 使用join方法连接元组中的元素
my_tuple = ('This', 'is', 'a', 'sentence.')
result = '-'.join(my_tuple)
print(result)  # 输出: This-is-a-sentence.

# 使用join方法连接集合中的元素
my_set = {'apple', 'banana', 'orange'}
result = ', '.join(my_set)
print(result)  # 输出: orange, apple, banana

my_dict = {'name':'马超','age':"18"}
result = '-'.join(my_dict.keys())
print(result)#输出: name-age

my_dict = {'name':'马超','age':"18"}
result = '-'.join(my_dict.values())
print(result)#输出: 马超-18



##=========>>> str.ljust()  左对齐

s = 'hello'  #左对齐
print(s.ljust(10),"word")
#hello      word




##=========>>> str.maketrans() 方法用于创建字符映射转换表。
#它接受三个可选参数x、y和z，这些参数可以是字符串或整数。

# 创建字符映射转换表
trans_table = str.maketrans("aeiou", "12345")
s = "hello world"

# 使用转换表进行字符替换
new_s = s.translate(trans_table)
print(new_s)  # 输出："h2ll4 w4rld"


# 创建字符映射转换表（使用整数）
trans_table = str.maketrans({97: "1", 101: "2", 105: "3", 111: "4", 117: "5"})
s = "hello"

# 使用转换表进行字符替换
new_s = s.translate(trans_table)
print(new_s)  # 输出："h2ll4"


# 创建字符映射转换表（使用多个参数）
trans_table = str.maketrans("abc", "xyz", "def")
s = "abcdef"

# 使用转换表进行字符替换  （替换abc，删除def）
new_s = s.translate(trans_table)
print(new_s)  # 输出："xyz"



##=========>>> str.partition()方法用于根据指定的分隔符将字符串分割成三部分：
# 分隔符之前的部分，分隔符本身和分隔符之后的部分。
# 它返回一个包含三个元素的元组。

s = "Hello, World!"
result = s.partition(", ")

print(result)  # 输出：('Hello', ', ', 'World!')




##=========>>> str.removeprefix(prefix, /)方法用于从字符串的开头删除指定的前缀。
# 它返回一个新的字符串，该字符串是原始字符串去除前缀后的结果。


s = "Hello, World!"
new_s = s.removeprefix("Hello")

print(new_s)  # 输出：", World!"


s = "World!"
new_s = s.removeprefix("Hello")

print(new_s)  # 输出："World!"



##=========>>> str.removesuffix(suffix, /)方法用于从字符串的末尾删除指定的后缀。
# 它返回一个新的字符串，该字符串是原始字符串去除后缀后的结果。


s = "Hello, World!"
new_s = s.removesuffix("World!")

print(new_s)  # 输出："Hello, "


s = "Hello, World!"
new_s = s.removesuffix("Hello")

print(new_s)  # 输出："Hello, World!"



##=========>>> str.replace(old, new[, count])方法用于将字符串中的指定子串（旧值）替换为新值。
# 它返回一个新的字符串，该字符串是替换后的结果。


s = "Hello, World!"
new_s = s.replace("Hello", "Hi")

print(new_s)  # 输出："Hi, World!"


s = "Hello, Hello, Hello!"
new_s = s.replace("Hello", "Hi", 2)

print(new_s)  # 输出："Hi, Hi, Hello!"


s = "Hello, World!"
new_s = s.replace("Hi", "Hello")

print(new_s)  # 输出："Hello, World!"


    
    
##=========>>> str.rfind(sub[, start[, end]])  方法用于从字符串的末尾向前搜索子串,
# 返回指定子串在字符串中最后一次出现的索引位置。
# 如果子串不在字符串中，则返回-1。


s = "Hello, World!"
index = s.rfind("o")

print(index)  # 输出：8

s = "Hello, World!"
index = s.rfind("x")

print(index)  # 输出：-1




##=========>>> str.rindex(sub[, start[, end]])方法,用于从字符串的末尾向前搜索子串,
# 返回指定子串在字符串中最后一次出现的索引位置。
#如果子串不在字符串中，则会引发一个ValueError错误。


s = "Hello, World!"
index = s.rindex("o")

print(index)  # 输出：8




s = "Hello, World!"
index = s.rindex("o", 0, 5)

print(index)  # 输出：4



s = "Hello, World!"

try:
    index = s.rindex("x")
    print(index)
except ValueError as e:
    print(e)  # 输出：substring not found



##=========>>> str.rjust() 右对齐
s = 'hello'
print(s.rjust(10))
#     hello



##=========>>> str.rpartition(sep)方法用于从字符串的末尾开始按照指定的分隔符将字符串进行分割，
# 并返回一个包含三个元素的元组。元组的第一个元素是分隔符之前的子串，
# 第二个元素是分隔符本身，第三个元素是分隔符之后的子串。


s = "Hello, World!"
result = s.rpartition(", ")

print(result)  # 输出：('Hello', ', ', 'World!')


s = "Hello, World!"
result = s.rpartition(";")

print(result)  # 输出：('', '', 'Hello, World!')


s = "apple, orange, banana, pear"
result = s.rpartition(", ")

print(result)  # 输出：('apple, orange, banana', ', ', 'pear')




##=========>>> str.rsplit(sep=None, maxsplit=-1)方法用于从字符串的末尾开始按照指定的分隔符将字符串进行分割，
# 并返回分割得到的子串列表。


s = "apple, orange, banana, pear"
result = s.rsplit(", ")

print(result)  # 输出：['apple', 'orange', 'banana', 'pear']


s = "apple, orange, banana, pear"
result = s.rsplit(", ", 2)

print(result)  # 输出：['apple, orange', 'banana', 'pear']




##=========>>> str.rstrip([chars])方法返回字符串的副本，删除字符串末尾的指定字符（或字符集）。
# 如果未提供参数，则默认删除字符串末尾的空白字符（空格、制表符、换行符等

text = "  Hello, World!  \t\n"
result = text.rstrip()  # 删除末尾的空白字符
print(result)  # 输出: "  Hello, World!"

text = "Hello, World!!!!!"
result = text.rstrip('!')  # 删除末尾的感叹号
print(result)  # 输出: "Hello, World"

text = "This is an example///"
result = text.rstrip('/')  # 删除末尾的斜杠
print(result)  # 输出: "This is an example"

text = "1111222233334444"
result = text.rstrip('4')  # 删除末尾的数字4
print(result)  # 输出: "111122223333"



##=========>>> str.split(sep=None, maxsplit=-1)方法将字符串分割成子字符串列表，并返回该列表。
# 如果未提供参数，则默认使用空格作为分隔符，最多分割到字符串的末尾。

text = "The quick brown fox jumps over the lazy dog."
words = text.split()  # 默认分隔符为空格
print(words)  # 输出: ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']

text = "apple,banana,cherry,orange"
fruits = text.split(',')  # 使用逗号作为分隔符
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'orange']

text = "one,two,,four,five"
items = text.split(',', 2)  # 最多分割成3个子字符串
print(items)  # 输出: ['one', 'two', ',four,five']




##=========>>> str.splitlines(keepends=False)方法将字符串按行分割，并返回一个包含各行作为元素的列表。
# 默认情况下，行尾的换行符不包含在结果中。


text = "Hello\nWorld\n"
lines = text.splitlines()
print(lines)  # 输出: ['Hello', 'World']

text = "Hello\r\nWorld\r\n"
lines = text.splitlines()
print(lines)  # 输出: ['Hello', 'World']

text = "Hello\nWorld\n"
lines = text.splitlines(keepends=True)
#保留换行符
print(lines)  # 输出: ['Hello\n', 'World\n']



##=========>>> str.startswith(prefix[, start[, end]])方法返回一个布尔值，指示字符串是否以给定的前缀开头。
# 如果提供了可选的start和end参数，则该方法将在指定范围内搜索。


text = "Hello, World!"

result = text.startswith("Hello")
print(result)  # 输出: True

result = text.startswith("World", 7)
print(result)  # 输出: True

result = text.startswith("o", 4, 6)
print(result)  # 输出: False



##=========>>> str.swapcase()方法返回一个新的字符串，其中大写字母被转换为小写字母，小写字母被转换为大写字母。


text = "Hello, World!"

result = text.swapcase()
print(result)  # 输出: hELLO, wORLD!


##=========>>> str.title()方法返回一个新的字符串，其中每个单词的首字母都被转换为大写。
text = "hello, world! it's a beautiful day."

result = text.title()
print(result)  # 输出: Hello, World! It'S A Beautiful Day.




##=========>>> str.translate(table)方法返回通过给定的转换表对字符串进行转换后的副本。
text = "Hello, World!"

# 创建转换表
translation_table = str.maketrans("HloW", "XlYZ")

result = text.translate(translation_table)
print(result)  # 输出: XeYY, Yrld!



##=========>>> str.upper()方法返回一个新的字符串，其中所有字母都被转换为大写字母。
text = "Hello, World!"

result = text.upper()
print(result)  # 输出: HELLO, WORLD!


##=========>>> str.zfill(width)方法返回一个指定宽度的新字符串，其中原字符串右对齐，并在左侧用零填充到指定的宽度。
text = "42"

result = text.zfill(5)
print(result)  # 输出: 00042



##=========>>>printf 风格的字符串格式化
print('%(language)s has %(number)03d quote types.' % {'language': "Python", "number": 2})
#Python has 002 quote types.   03d为三位数

name = "Alice"
age = 25

result = "My name is %s and I am %d years old." % (name, age)
print(result)  # 输出: My name is Alice and I am 25 years old.







